// 获取某年某月的天数
// 全缺省的构造函数
// 拷贝构造函数
// 赋值运算符重载
// 析构函数
// 日期+=天数
// 日期+天数
// 日期-天数
// 日期-=天数
// 前置++ --
// 后置++ --
// > == >= < <= != 日期 - 日期运算符重载

#include<iostream>
using namespace std;
class Date
{
    public:
    //获得某年某月的天数

    //在类中可以直接访问成员变量，所以我感觉这些参数可以不要的
    //这些参数必须要
    int monthDays[13] ={0,31,28,31,30,31,30,31,31,30,31,30,31};
    void  leap()
    {
        if((_year % 400 ==0) ||(_year % 4 == 0 && _year % 100 != 0))
        {
             monthDays[2] = 29;
        }
    }
    int getMonthDays()
    {
         //判断闰年
         leap();
         return monthDays[_month];
    }

    //全缺省构造函数
    Date(int year = 2025,int month = 4,int day = 29)
    {
        _year = year;
        _month = month;
        _day = day;
    }


    //拷贝构造函数：是构造函数的重载形式
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    //赋值运算符重载：
    //参数列表中的引用：避免出发拷贝构造函数，如果拷贝构造函数为正确定义的话，就会引发无穷递归
    // = ：赋值运算符重载 
    //默认生成的赋值运算符是以值的方式按字节拷贝的
    
    //按字节拷贝的，一定到注意自赋值检查，特别是涉及到动态内存管理
    Date& operator=(Date& d)
    {
        //自检查
       if(this != &d)
       {
        _year = d._year;
        _month = d._month;
        _day = d._day;
       }
      return *this;
    }

    //运算符+=
    Date& operator+=(int day)
    {
        //+= 天数，你要考虑进位的问题
        //int days = _day + day;
        //你上面这样写的画，你的天数没发生改变
        _day += day;
        while(_day > getMonthDays())
        {
            _day -= getMonthDays();
                _month++;
                if(_month == 13)
                {
                    _year++;
                    _month = 1;
                }
        }
        return *this;
    }

    //+ 运算符 - 运算符


    // 运算符 -=
    Date& operator-=(int day)
    {
       //int days = _day - day;
       _day -= day;
       while(_day <= 0)
       {
          _month --;
          if(_month == 0)
          {
            _year --;
            _month = 12;
          }
          _day += getMonthDays();
       }
       return *this;
    }

    //前置++
    //提高效率减少一个拷贝构造
    Date& operator++()
    {
        _day++;
        if(_day > getMonthDays())
        {
            _day = 1;
            _month++;
            if(_month == 13)
            {
                _year++;
                _month = 1;
            }
        }
        return *this;
    }
    //前置--
    Date& operator--()
    {
        _day --;
        if(_day == 0)
        {
            _month--;
            if(_month == 0)
            {
                _year --;
                _month = 12;
            }
            _day = getMonthDays();
        }
        
        return *this;
    }
   
    //后置++
    Date operator++(int)
    {
       Date tmp(*this);
       (*this)++;
       return tmp;
    }
     //后置--
    Date operator--(int)
    {
       Date tmp(*this);
       (*this)--;
       return tmp;
    }


    void Print()
    {
        cout <<_year <<" "<<_month <<" "<<_day <<'\n';
    }


    // > == >= < <= != 日期 - 日期运算符重载
    //编译器会给每个非静态成员增加一个隐含的this指针
    //this 指针的类型 Date  const * this
    bool operator > (Date& d)
    {
      if(_year > d._year) return true;
      else if(_year == d._year && _month > d._month) return true;
      else if(_year == d._year && _month == d._month && _day > d._day) return true;
      return false; 
    }
    
    // == 
    bool operator==(Date& d)
    {
        return _year == d._year && _month == d._month && _day == d._day;
    }

    bool operator>=(Date& d)
    {
        return *this > d || *this == d;//复用 
    }
    //<
    bool operator<(Date& d)
    {
       return !(*this >= d);
    }

    // <=
    bool operator<=(Date& d)
    {
       return !(*this > d);
    }

    //!=
    bool operator!=(Date& d)
    {
        return !(*this == d);
    }

    //a + 10但是a没变
    
    private:
    int _year;
    int _month;
    int _day;
};
int main()
{

}

